home *** CD-ROM | disk | FTP | other *** search
/ Network PC / Network PC.iso / amiga utilities / communication / bbs / termv4.6 / extras / source / term-source.lha / RatePanel.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-03-18  |  30.4 KB  |  1,475 lines
  1. /*
  2. **    RatePanel.c
  3. **
  4. **    Editing panel for phone units configuration
  5. **
  6. **    Copyright © 1990-1996 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. **
  9. **    :ts=4
  10. */
  11.  
  12. #ifndef _GLOBAL_H
  13. #include "Global.h"
  14. #endif
  15.  
  16. enum    {    GAD_TIME=1,GAD_ADDTIME,GAD_REMOVETIME,GAD_EDITTIME,
  17.             GAD_PAY1,GAD_MINUTES1,
  18.             GAD_PAY2,GAD_MINUTES2,
  19.             GAD_LIST,
  20.             GAD_ADDDATE,GAD_ADDDAY,GAD_EDIT,
  21.             GAD_CLONE,GAD_REMOVE,GAD_IMPORT
  22.         };
  23.  
  24. struct DoubleInfo
  25. {
  26.     LONG    GlyphWidth,
  27.             HeaderLen;
  28. };
  29.  
  30. VOID
  31. Rate2String(ULONG Rate,STRPTR String)
  32. {
  33.     if(Rate % 10000)
  34.     {
  35.         LONG i,Len;
  36.  
  37.         SPrintf(String,"%ld%lc%04ld",Rate / 10000,DecimalPoint,Rate % 10000);
  38.  
  39.         Len = strlen(String);
  40.  
  41.         for(i = Len - 1 ; i >= Len - 3 ; i--)
  42.         {
  43.             if(String[i] == '0')
  44.                 String[i] = 0;
  45.             else
  46.                 break;
  47.         }
  48.     }
  49.     else
  50.         SPrintf(String,"%ld",Rate / 10000);
  51. }
  52.  
  53. ULONG
  54. String2Rate(STRPTR String)
  55. {
  56.     ULONG Lead;
  57.     ULONG Follow;
  58.     ULONG Factor;
  59.     BOOL Decimal;
  60.     LONG i;
  61.  
  62.     Lead = 0;
  63.     Follow = 0;
  64.     Factor = 1000;
  65.     Decimal = FALSE;
  66.  
  67.     for(i = 0 ; i < strlen(String) ; i++)
  68.     {
  69.         if(String[i] == DecimalPoint)
  70.             Decimal = TRUE;
  71.         else
  72.         {
  73.             ULONG v = String[i] & 0xf;
  74.  
  75.             if(Decimal)
  76.             {
  77.                 Follow += v * Factor;
  78.  
  79.                 Factor /= 10;
  80.             }
  81.             else
  82.                 Lead = (10 * Lead) + v;
  83.         }
  84.     }
  85.  
  86.     return(Lead * 10000 + Follow);
  87. }
  88.  
  89. STATIC ULONG __saveds __asm
  90. RateEditRoutine(REG(a2) struct SGWork *Work,REG(a1) ULONG *Msg)
  91. {
  92.     if(*Msg == SGH_KEY)
  93.     {
  94.         ULONG Integral;
  95.         LONG i;
  96.         BOOL Decimal;
  97.         WORD Follow;
  98.         BOOL UseIt;
  99.         UBYTE c;
  100.  
  101.         Integral = 0;
  102.         Decimal = FALSE;
  103.         Follow = 0;
  104.         UseIt = TRUE;
  105.  
  106.         for(i = 0 ; i < strlen(Work->WorkBuffer) ; i++)
  107.         {
  108.             c = Work->WorkBuffer[i];
  109.  
  110.             if(c == '.')
  111.                 c = Work->WorkBuffer[i] = DecimalPoint;
  112.  
  113.             if(c == DecimalPoint)
  114.             {
  115.                 if(Decimal)
  116.                 {
  117.                     UseIt = FALSE;
  118.                     break;
  119.                 }
  120.                 else
  121.                     Decimal = TRUE;
  122.             }
  123.             else
  124.             {
  125.                 if(c >= '0' && c <= '9')
  126.                 {
  127.                     if(Decimal)
  128.                         Follow++;
  129.                     else
  130.                         Integral = (Integral * 10) + (c & 0xf);
  131.                 }
  132.                 else
  133.                 {
  134.                     UseIt = FALSE;
  135.                     break;
  136.                 }
  137.             }
  138.         }
  139.  
  140.         if(Follow > 4 || !UseIt || Integral > 429496)
  141.         {
  142.             Work->EditOp    = EO_BADFORMAT;
  143.             Work->Actions    = SGA_BEEP;
  144.         }
  145.     }
  146.     else
  147.     {
  148.         if(*Msg != SGH_CLICK)
  149.             return(FALSE);
  150.     }
  151.  
  152.     return(TRUE);
  153. }
  154.  
  155.     /* RateListViewRender():
  156.      *
  157.      *    This callback routine is responsible for rendering
  158.      *    the single listview entries.
  159.      */
  160.  
  161. STATIC ULONG __saveds __asm
  162. RateListViewRender(REG(a0) struct Hook *Hook,REG(a1) struct LVDrawMsg *Msg,REG(a2) struct Node *Node)
  163. {
  164.         /* We only know how to redraw lines. */
  165.  
  166.     if(Msg->lvdm_MethodID == LV_DRAW)
  167.     {
  168.         struct RastPort        *RPort    = Msg->lvdm_RastPort;
  169.         LONG                 Left    = Msg->lvdm_Bounds.MinX,
  170.                              Top    = Msg->lvdm_Bounds.MinY,
  171.                              Width    = Msg->lvdm_Bounds.MaxX - Msg->lvdm_Bounds.MinX + 1,
  172.                              Height    = Msg->lvdm_Bounds.MaxY - Msg->lvdm_Bounds.MinY + 1,
  173.                              Delta,
  174.                              FgPen,BgPen,
  175.                              Len,LabelLen,Template;
  176.         UBYTE                *String,Header[8];
  177.         struct DoubleInfo    *Info;
  178.         UWORD                *Pens;
  179.  
  180.         Pens = Msg->lvdm_DrawInfo->dri_Pens;
  181.  
  182.         Info = Hook->h_Data;
  183.  
  184.         String = &Node->ln_Name[Info->HeaderLen];
  185.  
  186.         CopyMem(Node->ln_Name,Header,Info->HeaderLen);
  187.  
  188.         Header[Info->HeaderLen] = 0;
  189.  
  190.             /* Determine the rendering pens. */
  191.  
  192.         if(Msg->lvdm_State == LVR_SELECTED)
  193.         {
  194.             FgPen = FILLTEXTPEN;
  195.             BgPen = FILLPEN;
  196.         }
  197.         else
  198.         {
  199.             FgPen = TEXTPEN;
  200.             BgPen = BACKGROUNDPEN;
  201.         }
  202.  
  203.         FgPen = Pens[FgPen];
  204.         BgPen = Pens[BgPen];
  205.  
  206.             /* Set the rendering pens. */
  207.  
  208.         SetABPenDrMd(RPort,BgPen,BgPen,JAM2);
  209.  
  210.         RectFill(RPort,Left,Top,Left + 1,Top + Height - 1);
  211.  
  212.         Left    += 2;
  213.         Width    -= 2;
  214.  
  215.         Template = Info->HeaderLen * Info->GlyphWidth;
  216.  
  217.             /* Determine header length. */
  218.  
  219.         Len = TextLength(RPort,Header,Info->HeaderLen);
  220.  
  221.             /* Fill the space to precede the header. */
  222.  
  223.         if((Delta = Template - Len) > 0)
  224.         {
  225.             SetAPen(RPort,BgPen);
  226.             FillBox(RPort,Left,Top,Delta,Height);
  227.         }
  228.  
  229.             /* Render the header, right-justified. */
  230.  
  231.         SetAPen(RPort,FgPen);
  232.  
  233.         PlaceText(RPort,Left + Delta,Top,Header,Info->HeaderLen);
  234.  
  235.             /* Adjust width and area left edge. */
  236.  
  237.         Left    += Template;
  238.         Width    -= Template;
  239.  
  240.             /* Determine length of vanilla name. */
  241.  
  242.         LabelLen = strlen(String);
  243.  
  244.             /* Try to make it fit. */
  245.  
  246.         while(LabelLen > 0 && (Len = TextLength(RPort,String,LabelLen)) > Width)
  247.             LabelLen--;
  248.  
  249.             /* Print the vanilla name if possible. */
  250.  
  251.         if(LabelLen)
  252.         {
  253.             PlaceText(RPort,Left,Top,String,LabelLen);
  254.  
  255.             Left    += Len;
  256.             Width    -= Len;
  257.         }
  258.  
  259.             /* Fill the area to follow the vanilla name. */
  260.  
  261.         if(Width > 0)
  262.         {
  263.             SetAPen(RPort,BgPen);
  264.             FillBox(RPort,Left,Top,Width,Height);
  265.         }
  266.  
  267.             /* If the item happens to be disabled, draw the cross-hatch
  268.              * pattern across it.
  269.              */
  270.  
  271.         ListViewStateFill(Msg);
  272.  
  273.         return(LVCB_OK);
  274.     }
  275.     else
  276.         return(LVCB_UNKNOWN);
  277. }
  278.  
  279. STATIC VOID
  280. DisableGadgets(struct LayoutHandle *Handle,BOOL Mode,BOOL SetEntries,BOOL SetTime)
  281. {
  282.     LT_SetAttributes(Handle,GAD_PAY1,
  283.         GA_Disabled,    Mode,
  284.     TAG_DONE);
  285.  
  286.     LT_SetAttributes(Handle,GAD_MINUTES1,
  287.         GA_Disabled,    Mode,
  288.     TAG_DONE);
  289.  
  290.     LT_SetAttributes(Handle,GAD_PAY2,
  291.         GA_Disabled,    Mode,
  292.     TAG_DONE);
  293.  
  294.     LT_SetAttributes(Handle,GAD_MINUTES2,
  295.         GA_Disabled,    Mode,
  296.     TAG_DONE);
  297.  
  298.     if(SetEntries)
  299.     {
  300.         LT_SetAttributes(Handle,GAD_EDIT,
  301.             GA_Disabled,    Mode,
  302.         TAG_DONE);
  303.  
  304.         LT_SetAttributes(Handle,GAD_CLONE,
  305.             GA_Disabled,    Mode,
  306.         TAG_DONE);
  307.  
  308.         LT_SetAttributes(Handle,GAD_REMOVE,
  309.             GA_Disabled,    Mode,
  310.         TAG_DONE);
  311.     }
  312.  
  313.     if(SetTime)
  314.     {
  315.         LT_SetAttributes(Handle,GAD_TIME,
  316.             GA_Disabled,    Mode,
  317.         TAG_DONE);
  318.  
  319.         LT_SetAttributes(Handle,GAD_ADDTIME,
  320.             GA_Disabled,    Mode,
  321.         TAG_DONE);
  322.  
  323.         LT_SetAttributes(Handle,GAD_REMOVETIME,
  324.             GA_Disabled,    Mode,
  325.         TAG_DONE);
  326.  
  327.         LT_SetAttributes(Handle,GAD_EDITTIME,
  328.             GA_Disabled,    Mode,
  329.         TAG_DONE);
  330.     }
  331. }
  332.  
  333. BOOL
  334. RatePanel(struct Window *Parent,struct List *PhoneList,struct PhoneEntry *Entry,struct List *TimeDateList)
  335. {
  336.     STATIC struct DoubleInfo TimeInfo;
  337.  
  338.     STATIC struct Hook TimeHook =
  339.     {
  340.         {NULL},
  341.         (HOOKFUNC)RateListViewRender,
  342.         (HOOKFUNC)NULL,
  343.         &TimeInfo
  344.     };
  345.  
  346.     STATIC struct DoubleInfo DateInfo;
  347.  
  348.     STATIC struct Hook DateHook =
  349.     {
  350.         {NULL},
  351.         (HOOKFUNC)RateListViewRender,
  352.         (HOOKFUNC)NULL,
  353.         &DateInfo
  354.     };
  355.  
  356.     STATIC struct Hook RateHook =
  357.     {
  358.         {NULL},
  359.         (HOOKFUNC)RateEditRoutine
  360.     };
  361.  
  362.     struct LayoutHandle    *Handle;
  363.     BOOL                 MadeChanges = FALSE;
  364.  
  365.     if(!TimeDateList)
  366.         TimeDateList = (struct List *)&Entry->TimeDateList;
  367.  
  368.     if(Handle = LT_CreateHandleTags(Parent->WScreen,
  369.         LH_LocaleHook,    &LocaleHook,
  370.     TAG_DONE))
  371.     {
  372.         STATIC WORD ButtonLabels[] =
  373.         {
  374.             MSG_RATEPANEL_ADD_TIME_GAD,
  375.             MSG_RATEPANEL_REMOVE_TIME_GAD,
  376.             MSG_RATEPANEL_EDIT_TIME_GAD,
  377.  
  378.             MSG_RATEPANEL_ADD_DATE_GAD,
  379.             MSG_RATEPANEL_ADD_DAYS_GAD,
  380.             MSG_RATEPANEL_EDIT_GAD,
  381.  
  382.             MSG_RATEPANEL_CLONE_GAD,
  383.             MSG_GLOBAL_REMOVE_GAD,
  384.             MSG_RATEPANEL_IMPORT_GAD
  385.         };
  386.  
  387.         struct Window    *PanelWindow;
  388.         LONG             i,Max = 0,Size;
  389.         UBYTE             SmallString[2];
  390.  
  391.         SmallString[1] = 0;
  392.  
  393.         for(i = '0' ; i <= '9' ; i++)
  394.         {
  395.             SmallString[0] = i;
  396.  
  397.             if((Size = LT_LabelWidth(Handle,SmallString)) > Max)
  398.                 Max = Size;
  399.         }
  400.  
  401.         TimeInfo.GlyphWidth    = Max;
  402.         TimeInfo.HeaderLen    = 2;
  403.  
  404.         DateInfo.GlyphWidth    = Max;
  405.         DateInfo.HeaderLen    = 7;
  406.  
  407.         for(i = Max = 0 ; i < NumElements(ButtonLabels) ; i++)
  408.         {
  409.             if((Size = LT_LabelChars(Handle,LocaleString(ButtonLabels[i]))) > Max)
  410.                 Max = Size;
  411.         }
  412.  
  413.         LT_New(Handle,
  414.             LA_Type,    VERTICAL_KIND,
  415.         TAG_DONE);
  416.         {
  417.             LT_New(Handle,
  418.                 LA_Type,    HORIZONTAL_KIND,
  419.                 LA_LabelID,    MSG_V36_0157,
  420.             TAG_DONE);
  421.             {
  422.                 LT_New(Handle,
  423.                     LA_Type,    HORIZONTAL_KIND,
  424.                 TAG_DONE);
  425.                 {
  426.                     LT_New(Handle,
  427.                         LA_Type,        LISTVIEW_KIND,
  428.                         LA_LabelID,        MSG_RATEPANEL_DAYS_AND_DATES_GAD,
  429.                         LA_Chars,        30,
  430.                         LA_Lines,        10,
  431.                         LA_ID,            GAD_LIST,
  432.                         GTLV_CallBack,    &DateHook,
  433.                         GTLV_MaxPen,    GetListMaxPen(Handle->DrawInfo->dri_Pens),
  434.                         GTLV_Labels,    TimeDateList,
  435.                         LALV_Link,        NIL_LINK,
  436.  
  437.                         Kick30 ? TAG_IGNORE : LALV_TextAttr, ~0,
  438.                     TAG_DONE);
  439.  
  440.                     LT_New(Handle,
  441.                         LA_Type,        LISTVIEW_KIND,
  442.                         LA_LabelID,        MSG_RATEPANEL_TIME_GAD,
  443.                         LA_Chars,        10,
  444.                         LA_Lines,        10,
  445.                         LA_ID,            GAD_TIME,
  446.                         GA_Disabled,    TRUE,
  447.                         GTLV_CallBack,    &TimeHook,
  448.                         GTLV_MaxPen,    GetListMaxPen(Handle->DrawInfo->dri_Pens),
  449.                         LALV_Link,        NIL_LINK,
  450.  
  451.                         Kick30 ? TAG_IGNORE : LALV_TextAttr, ~0,
  452.                     TAG_DONE);
  453.  
  454.                     LT_EndGroup(Handle);
  455.                 }
  456.  
  457.                 LT_New(Handle,
  458.                     LA_Type,    VERTICAL_KIND,
  459.                 TAG_DONE);
  460.                 {
  461.                     LT_New(Handle,
  462.                         LA_Type,        VERTICAL_KIND,
  463.                         LA_LabelID,        MSG_RATEPANEL_FIRST_UNIT_GAD,
  464.                         LAGR_SameSize,    TRUE,
  465.                     TAG_DONE);
  466.                     {
  467.                         LT_New(Handle,
  468.                             LA_Type,            STRING_KIND,
  469.                             LA_LabelText,        SmallCurrency(),
  470.                             LA_ID,                GAD_PAY1,
  471.                             LA_Chars,            6,
  472.                             GTST_MaxChars,        11,
  473.                             GTST_EditHook,        &RateHook,
  474.                             GA_Disabled,        TRUE,
  475.                         TAG_DONE);
  476.  
  477.                         LT_New(Handle,
  478.                             LA_Type,            STRING_KIND,
  479.                             LA_LabelID,            MSG_RATEPANEL_SECONDS_PER_UNIT_GAD,
  480.                             LA_ID,                GAD_MINUTES1,
  481.                             GTST_MaxChars,        11,
  482.                             GTST_EditHook,        &RateHook,
  483.                             GA_Disabled,        TRUE,
  484.                         TAG_DONE);
  485.  
  486.                         LT_EndGroup(Handle);
  487.                     }
  488.  
  489.                     LT_New(Handle,
  490.                         LA_Type,        VERTICAL_KIND,
  491.                         LA_LabelID,        MSG_RATEPANEL_FOLLOWING_UNITS_GAD,
  492.                         LAGR_SameSize,    TRUE,
  493.                     TAG_DONE);
  494.                     {
  495.                         LT_New(Handle,
  496.                             LA_Type,            STRING_KIND,
  497.                             LA_LabelText,        SmallCurrency(),
  498.                             LA_ID,                GAD_PAY2,
  499.                             GA_Disabled,        TRUE,
  500.                             GTST_MaxChars,        11,
  501.                             GTST_EditHook,        &RateHook,
  502.                         TAG_DONE);
  503.  
  504.                         LT_New(Handle,
  505.                             LA_Type,            STRING_KIND,
  506.                             LA_LabelID,            MSG_RATEPANEL_SECONDS_PER_UNIT_GAD,
  507.                             LA_ID,                GAD_MINUTES2,
  508.                             LA_Chars,            6,
  509.                             GTST_MaxChars,        11,
  510.                             GTST_EditHook,        &RateHook,
  511.                             GA_Disabled,        TRUE,
  512.                         TAG_DONE);
  513.  
  514.                         LT_EndGroup(Handle);
  515.                     }
  516.  
  517.                     LT_EndGroup(Handle);
  518.                 }
  519.  
  520.                 LT_EndGroup(Handle);
  521.             }
  522.  
  523.             LT_New(Handle,
  524.                 LA_Type,    VERTICAL_KIND,
  525.             TAG_DONE);
  526.             {
  527.                 LT_New(Handle,
  528.                     LA_Type,        XBAR_KIND,
  529.                     LAXB_FullSize,    TRUE,
  530.                 TAG_DONE);
  531.  
  532.                 LT_EndGroup(Handle);
  533.             }
  534.  
  535.             LT_New(Handle,LA_Type,HORIZONTAL_KIND,
  536.                 LAGR_Spread,    TRUE,
  537.                 LAGR_SameSize,    TRUE,
  538.             TAG_DONE);
  539.             {
  540.                 LT_New(Handle,
  541.                     LA_Type,        BUTTON_KIND,
  542.                     LA_LabelID,        MSG_RATEPANEL_ADD_TIME_GAD,
  543.                     LA_ID,            GAD_ADDTIME,
  544.                     LA_Chars,        Max,
  545.                     GA_Disabled,    TRUE,
  546.                 TAG_DONE);
  547.  
  548.                 LT_New(Handle,
  549.                     LA_Type,        BUTTON_KIND,
  550.                     LA_LabelID,        MSG_RATEPANEL_REMOVE_TIME_GAD,
  551.                     LA_ID,            GAD_REMOVETIME,
  552.                     GA_Disabled,    TRUE,
  553.                 TAG_DONE);
  554.  
  555.                 LT_New(Handle,
  556.                     LA_Type,        BUTTON_KIND,
  557.                     LA_LabelID,        MSG_RATEPANEL_EDIT_TIME_GAD,
  558.                     LA_ID,            GAD_EDITTIME,
  559.                     GA_Disabled,    TRUE,
  560.                 TAG_DONE);
  561.  
  562.                 LT_EndGroup(Handle);
  563.             }
  564.  
  565.             LT_New(Handle,
  566.                 LA_Type,    VERTICAL_KIND,
  567.             TAG_DONE);
  568.             {
  569.                 LT_New(Handle,
  570.                     LA_Type,        XBAR_KIND,
  571.                 TAG_DONE);
  572.  
  573.                 LT_EndGroup(Handle);
  574.             }
  575.  
  576.             LT_New(Handle,LA_Type,HORIZONTAL_KIND,
  577.                 LAGR_Spread,    TRUE,
  578.                 LAGR_SameSize,    TRUE,
  579.             TAG_DONE);
  580.             {
  581.                 LT_New(Handle,
  582.                     LA_Type,        BUTTON_KIND,
  583.                     LA_LabelID,        MSG_RATEPANEL_ADD_DATE_GAD,
  584.                     LA_ID,            GAD_ADDDATE,
  585.                     LA_Chars,        Max,
  586.                 TAG_DONE);
  587.  
  588.                 LT_New(Handle,
  589.                     LA_Type,        BUTTON_KIND,
  590.                     LA_LabelID,        MSG_RATEPANEL_ADD_DAYS_GAD,
  591.                     LA_ID,            GAD_ADDDAY,
  592.                 TAG_DONE);
  593.  
  594.                 LT_New(Handle,
  595.                     LA_Type,        BUTTON_KIND,
  596.                     LA_LabelID,        MSG_RATEPANEL_EDIT_GAD,
  597.                     LA_ID,            GAD_EDIT,
  598.                     GA_Disabled,    TRUE,
  599.                 TAG_DONE);
  600.  
  601.                 LT_EndGroup(Handle);
  602.             }
  603.  
  604.             LT_New(Handle,LA_Type,HORIZONTAL_KIND,
  605.                 LAGR_Spread,    TRUE,
  606.                 LAGR_SameSize,    TRUE,
  607.             TAG_DONE);
  608.             {
  609.                 LT_New(Handle,
  610.                     LA_Type,        BUTTON_KIND,
  611.                     LA_LabelID,        MSG_RATEPANEL_CLONE_GAD,
  612.                     LA_ID,            GAD_CLONE,
  613.                     LA_Chars,        Max,
  614.                     GA_Disabled,    TRUE,
  615.                 TAG_DONE);
  616.  
  617.                 LT_New(Handle,
  618.                     LA_Type,        BUTTON_KIND,
  619.                     LA_LabelID,        MSG_GLOBAL_REMOVE_GAD,
  620.                     LA_ID,            GAD_REMOVE,
  621.                     GA_Disabled,    TRUE,
  622.                 TAG_DONE);
  623.  
  624.                 LT_New(Handle,
  625.                     LA_Type,        BUTTON_KIND,
  626.                     LA_LabelID,        MSG_RATEPANEL_IMPORT_GAD,
  627.                     LA_ID,            GAD_IMPORT,
  628.                     GA_Disabled,    !PhoneList,
  629.                 TAG_DONE);
  630.  
  631.                 LT_EndGroup(Handle);
  632.             }
  633.  
  634.             LT_EndGroup(Handle);
  635.         }
  636.  
  637.         if(PanelWindow = LT_Build(Handle,
  638.             LAWN_TitleID,        MSG_RATEPANEL_RATES_PREFERENCES_TXT,
  639.             LAWN_IDCMP,            IDCMP_CLOSEWINDOW,
  640.             LAWN_HelpHook,        &GuideHook,
  641.             LAWN_Parent,        Parent,
  642.             WA_DepthGadget,        TRUE,
  643.             WA_CloseGadget,        TRUE,
  644.             WA_DragBar,            TRUE,
  645.             WA_RMBTrap,            TRUE,
  646.             WA_Activate,        TRUE,
  647.             WA_SimpleRefresh,    TRUE,
  648.         TAG_DONE))
  649.         {
  650.             struct IntuiMessage    *Message;
  651.             BOOL                 Done = FALSE;
  652.             ULONG                 MsgClass;
  653.             UWORD                 MsgCode;
  654.             struct Gadget        *MsgGadget;
  655.             LONG                 MsgGadgetID;
  656.  
  657.             BOOL                 Redisplay;
  658.  
  659.             struct TimeDateNode    *TimeDateNode,
  660.                                 *NewNode;
  661.             struct List            *TimeList        = NULL;
  662.             LONG                 Selected        = ~0,
  663.                                  Count            =  0,
  664.                                  TimeSelected    = ~0;
  665.  
  666.             UBYTE                 PayString1[20],
  667.                                  PayString2[20];
  668.             UBYTE                 TimeString1[20],
  669.                                  TimeString2[20];
  670.  
  671.             GuideContext(CONTEXT_RATES);
  672.  
  673.             TimeDateNode = (struct TimeDateNode *)TimeDateList->lh_Head;
  674.  
  675.             while(TimeDateNode->VanillaNode.ln_Succ)
  676.             {
  677.                 Count++;
  678.  
  679.                 TimeDateNode = (struct TimeDateNode *)TimeDateNode->VanillaNode.ln_Succ;
  680.             }
  681.  
  682.             PushWindow(PanelWindow);
  683.  
  684.             Redisplay = FALSE;
  685.  
  686.             LT_ShowWindow(Handle,TRUE);
  687.  
  688.             do
  689.             {
  690.                 if(Wait(PORTMASK(PanelWindow->UserPort) | SIG_BREAK) & SIG_BREAK)
  691.                     break;
  692.  
  693.                 while(Message = (struct IntuiMessage *)LT_GetIMsg(Handle))
  694.                 {
  695.                     MsgClass    = Message->Class;
  696.                     MsgCode        = Message->Code;
  697.                     MsgGadget    = (struct Gadget *)Message->IAddress;
  698.  
  699.                     LT_ReplyIMsg(Message);
  700.  
  701.                     if(MsgClass == IDCMP_CLOSEWINDOW)
  702.                         Done = TRUE;
  703.  
  704.                     MsgGadgetID = -1;
  705.  
  706.                     if(MsgClass == IDCMP_GADGETUP)
  707.                         MsgGadgetID = MsgGadget->GadgetID;
  708.  
  709.                     if(MsgClass == IDCMP_IDCMPUPDATE)
  710.                     {
  711.                         switch(MsgGadget->GadgetID)
  712.                         {
  713.                             case GAD_TIME:
  714.  
  715.                                 if(Selected != ~0 && TimeSelected != ~0)
  716.                                     MsgGadgetID = GAD_EDITTIME;
  717.  
  718.                                 break;
  719.  
  720.                             case GAD_LIST:
  721.  
  722.                                 if(Selected != ~0 && Selected > 0)
  723.                                     MsgGadgetID = GAD_EDIT;
  724.  
  725.                                 break;
  726.                         }
  727.  
  728.                         if(MsgGadgetID != -1)
  729.                             LT_PressButton(Handle,MsgGadgetID);
  730.                     }
  731.  
  732.                     if(MsgGadgetID != -1)
  733.                     {
  734.                         switch(MsgGadgetID)
  735.                         {
  736.                             case GAD_TIME:
  737.  
  738.                                 TimeSelected = MsgCode;
  739.  
  740.                                 if(Selected != ~0)
  741.                                 {
  742.                                     Rate2String(TimeDateNode->Table[TimeSelected].PayPerUnit[DT_FIRST_UNIT],PayString1);
  743.  
  744.                                     LT_SetAttributes(Handle,GAD_PAY1,
  745.                                         GTST_String,    PayString1,
  746.                                     TAG_DONE);
  747.  
  748.                                     Rate2String(TimeDateNode->Table[TimeSelected].SecPerUnit[DT_FIRST_UNIT],TimeString1);
  749.  
  750.                                     LT_SetAttributes(Handle,GAD_MINUTES1,
  751.                                         GTST_String,    TimeString1,
  752.                                     TAG_DONE);
  753.  
  754.                                     Rate2String(TimeDateNode->Table[TimeSelected].PayPerUnit[DT_NEXT_UNIT],PayString2);
  755.  
  756.                                     LT_SetAttributes(Handle,GAD_PAY2,
  757.                                         GTST_String,    PayString2,
  758.                                     TAG_DONE);
  759.  
  760.                                     Rate2String(TimeDateNode->Table[TimeSelected].SecPerUnit[DT_NEXT_UNIT],TimeString2);
  761.  
  762.                                     LT_SetAttributes(Handle,GAD_MINUTES2,
  763.                                         GTST_String,    TimeString2,
  764.                                     TAG_DONE);
  765.                                 }
  766.  
  767.                                 break;
  768.  
  769.                             case GAD_EDITTIME:
  770.  
  771.                                 if(Selected != ~0 && TimeSelected != ~0)
  772.                                 {
  773.                                         // Make a backup in case we need to restore it later
  774.  
  775.                                     LONG Time = TimeDateNode->Table[TimeSelected].Time;
  776.  
  777.                                     LT_LockWindow(PanelWindow);
  778.  
  779.                                         // Edit the time
  780.  
  781.                                     if(TimePanel(PanelWindow,&TimeDateNode->Table[TimeSelected].Time))
  782.                                     {
  783.                                         struct List *NewTimeList;
  784.  
  785.                                         MadeChanges = TRUE;
  786.  
  787.                                             // Make a mark so we can find it later
  788.  
  789.                                         TimeDateNode->Table[TimeSelected].Mark = TRUE;
  790.  
  791.                                             // Sort the times in ascending order
  792.  
  793.                                         SortTimeTable(TimeDateNode);
  794.  
  795.                                             // Find the previously selected item
  796.  
  797.                                         for(i = 0 ; i < TimeDateNode->Table[0].Count ; i++)
  798.                                         {
  799.                                             if(TimeDateNode->Table[i].Mark)
  800.                                             {
  801.                                                 TimeSelected = i;
  802.                                                 break;
  803.                                             }
  804.                                         }
  805.  
  806.                                             // Create a new time display list
  807.  
  808.                                         if(NewTimeList = BuildTimeList(TimeDateNode))
  809.                                         {
  810.                                                 // Update the list display
  811.  
  812.                                             LT_SetAttributes(Handle,GAD_TIME,
  813.                                                 GTLV_Labels,    NewTimeList,
  814.                                                 GTLV_Selected,    TimeSelected,
  815.                                             TAG_DONE);
  816.  
  817.                                                 // Replace old list with new list
  818.  
  819.                                             FreeVecPooled(TimeList);
  820.  
  821.                                             TimeList = NewTimeList;
  822.                                         }
  823.                                         else
  824.                                         {
  825.                                                 // So that didn't work; restore the old time
  826.  
  827.                                             TimeDateNode->Table[TimeSelected].Time = Time;
  828.  
  829.                                                 // Bring back the original sorting order
  830.  
  831.                                             SortTimeTable(TimeDateNode);
  832.  
  833.                                                 // Find the original item position
  834.  
  835.                                             for(i = 0 ; i < TimeDateNode->Table[0].Count ; i++)
  836.                                             {
  837.                                                 if(TimeDateNode->Table[i].Mark)
  838.                                                 {
  839.                                                     TimeSelected = i;
  840.                                                     break;
  841.                                                 }
  842.                                             }
  843.  
  844.                                                 // And restore the display
  845.  
  846.                                             LT_SetAttributes(Handle,GAD_TIME,
  847.                                                 GTLV_Selected,TimeSelected,
  848.                                             TAG_DONE);
  849.  
  850.                                             DisplayBeep(PanelWindow->WScreen);
  851.                                         }
  852.  
  853.                                             // Remove the mark
  854.  
  855.                                         TimeDateNode->Table[TimeSelected].Mark = FALSE;
  856.                                     }
  857.  
  858.                                     LT_UnlockWindow(PanelWindow);
  859.  
  860.                                     LT_ShowWindow(Handle,TRUE);
  861.                                 }
  862.  
  863.                                 break;
  864.  
  865.                             case GAD_REMOVETIME:
  866.  
  867.                                 if(Selected != ~0 && TimeSelected != ~0)
  868.                                 {
  869.                                     MadeChanges = TRUE;
  870.  
  871.                                     LT_LockWindow(PanelWindow);
  872.  
  873.                                     LT_SetAttributes(Handle,GAD_TIME,
  874.                                         GTLV_Labels,    ~0,
  875.                                     TAG_DONE);
  876.  
  877.                                     if(DeleteTimeDateNode(TimeDateNode,TimeSelected))
  878.                                     {
  879.                                         FreeVecPooled(TimeList);
  880.  
  881.                                         if(TimeList = BuildTimeList(TimeDateNode))
  882.                                         {
  883.                                             LT_SetAttributes(Handle,GAD_TIME,
  884.                                                 GTLV_Labels,    TimeList,
  885.                                                 GTLV_Selected,    ~0,
  886.                                                 GA_Disabled,    TRUE,
  887.                                             TAG_DONE);
  888.  
  889.                                             TimeSelected = ~0;
  890.  
  891.                                             LT_SetAttributes(Handle,GAD_LIST,
  892.                                                 GTLV_Labels,    TimeDateList,
  893.                                                 GTLV_Selected,    ~0,
  894.                                             TAG_DONE);
  895.  
  896.                                             DisableGadgets(Handle,TRUE,TRUE,TRUE);
  897.  
  898.                                             Selected = ~0;
  899.                                         }
  900.                                         else
  901.                                         {
  902.                                             LT_SetAttributes(Handle,GAD_TIME,
  903.                                                 GTLV_Labels,    NULL,
  904.                                                 GTLV_Selected,    ~0,
  905.                                             TAG_DONE);
  906.  
  907.                                             TimeSelected = ~0;
  908.  
  909.                                             DisplayBeep(PanelWindow->WScreen);
  910.                                         }
  911.                                     }
  912.                                     else
  913.                                     {
  914.                                         LT_SetAttributes(Handle,GAD_TIME,
  915.                                             GTLV_Labels,    TimeList,
  916.                                             GTLV_Selected,    TimeSelected,
  917.                                         TAG_DONE);
  918.  
  919.                                         DisplayBeep(PanelWindow->WScreen);
  920.                                     }
  921.  
  922.                                     LT_UnlockWindow(PanelWindow);
  923.                                 }
  924.  
  925.                                 break;
  926.  
  927.                             case GAD_ADDTIME:
  928.  
  929.                                 if(Selected != ~0)
  930.                                 {
  931.                                     UBYTE Time = DT_GET_TIME(12,0);
  932.  
  933.                                     MadeChanges = TRUE;
  934.  
  935.                                     LT_LockWindow(PanelWindow);
  936.  
  937.                                         // Get the new time
  938.  
  939.                                     if(TimePanel(PanelWindow,&Time))
  940.                                     {
  941.                                         BOOL AddIt = TRUE;
  942.                                         LONG i;
  943.  
  944.                                             // Check if this moment already exists
  945.  
  946.                                         for(i = 0 ; i < TimeDateNode->Table[0].Count ; i++)
  947.                                         {
  948.                                             if(Time == TimeDateNode->Table[i].Time)
  949.                                             {
  950.                                                 AddIt = FALSE;
  951.                                                 break;
  952.                                             }
  953.                                         }
  954.  
  955.                                             // Don't add it if it's already in there
  956.  
  957.                                         if(AddIt)
  958.                                         {
  959.                                             LT_SetAttributes(Handle,GAD_TIME,
  960.                                                 GTLV_Labels,    ~0,
  961.                                             TAG_DONE);
  962.  
  963.                                                 // Make a mark so we can find this entry later
  964.  
  965.                                             TimeDateNode->Table[TimeSelected].Mark = TRUE;
  966.  
  967.                                                 // Add one new entry
  968.  
  969.                                             if(ResizeTimeDateNode(TimeDateNode,TimeDateNode->Table[0].Count + 1,Time))
  970.                                             {
  971.                                                     // Restore the proper order
  972.  
  973.                                                 SortTimeTable(TimeDateNode);
  974.  
  975.                                                     // Find the originally selected item
  976.  
  977.                                                 for(i = 0 ; i < TimeDateNode->Table[0].Count ; i++)
  978.                                                 {
  979.                                                     if(TimeDateNode->Table[i].Mark)
  980.                                                     {
  981.                                                         TimeSelected = i;
  982.                                                         TimeDateNode->Table[i].Mark = FALSE;
  983.                                                         break;
  984.                                                     }
  985.                                                 }
  986.  
  987.                                                     // Build new display list
  988.  
  989.                                                 FreeVecPooled(TimeList);
  990.  
  991.                                                 if(TimeList = BuildTimeList(TimeDateNode))
  992.                                                 {
  993.                                                     LT_SetAttributes(Handle,GAD_TIME,
  994.                                                         GTLV_Labels,    TimeList,
  995.                                                         GTLV_Selected,    TimeSelected,
  996.                                                         GA_Disabled,    FALSE,
  997.                                                     TAG_DONE);
  998.                                                 }
  999.                                                 else
  1000.                                                 {
  1001.                                                     LT_SetAttributes(Handle,GAD_TIME,
  1002.                                                         GTLV_Labels,    NULL,
  1003.                                                         GTLV_Selected,    ~0,
  1004.                                                     TAG_DONE);
  1005.  
  1006.                                                     TimeSelected = ~0;
  1007.  
  1008.                                                     DisplayBeep(PanelWindow->WScreen);
  1009.                                                 }
  1010.                                             }
  1011.                                             else
  1012.                                             {
  1013.                                                     // Clear the mark
  1014.  
  1015.                                                 TimeDateNode->Table[TimeSelected].Mark = FALSE;
  1016.  
  1017.                                                     // Restore the list
  1018.  
  1019.                                                 LT_SetAttributes(Handle,GAD_TIME,
  1020.                                                     GTLV_Labels,    TimeList,
  1021.                                                     GTLV_Selected,    TimeSelected,
  1022.                                                 TAG_DONE);
  1023.  
  1024.                                                 DisplayBeep(PanelWindow->WScreen);
  1025.                                             }
  1026.                                         }
  1027.                                     }
  1028.  
  1029.                                     LT_UnlockWindow(PanelWindow);
  1030.  
  1031.                                     LT_ShowWindow(Handle,TRUE);
  1032.                                 }
  1033.  
  1034.                                 break;
  1035.  
  1036.                             case GAD_PAY1:
  1037.  
  1038.                                 TimeDateNode->Table[TimeSelected].PayPerUnit[DT_FIRST_UNIT] = String2Rate(LT_GetString(Handle,MsgGadgetID));
  1039.  
  1040.                                 MadeChanges = TRUE;
  1041.  
  1042.                                 break;
  1043.  
  1044.                             case GAD_PAY2:
  1045.  
  1046.                                 TimeDateNode->Table[TimeSelected].PayPerUnit[DT_NEXT_UNIT] = String2Rate(LT_GetString(Handle,MsgGadgetID));
  1047.  
  1048.                                 MadeChanges = TRUE;
  1049.  
  1050.                                 break;
  1051.  
  1052.                             case GAD_MINUTES1:
  1053.  
  1054.                                 TimeDateNode->Table[TimeSelected].SecPerUnit[DT_FIRST_UNIT] = String2Rate(LT_GetString(Handle,MsgGadgetID));
  1055.  
  1056.                                 MadeChanges = TRUE;
  1057.  
  1058.                                 break;
  1059.  
  1060.                             case GAD_MINUTES2:
  1061.  
  1062.                                 TimeDateNode->Table[TimeSelected].SecPerUnit[DT_NEXT_UNIT] = String2Rate(LT_GetString(Handle,MsgGadgetID));
  1063.  
  1064.                                 MadeChanges = TRUE;
  1065.  
  1066.                                 break;
  1067.  
  1068.                             case GAD_LIST:
  1069.  
  1070.                                 LT_SetAttributes(Handle,GAD_TIME,
  1071.                                     GTLV_Labels,~0,
  1072.                                 TAG_DONE);
  1073.  
  1074.                                 FreeVecPooled(TimeList);
  1075.  
  1076.                                 TimeDateNode = (struct TimeDateNode *)GetListNode(MsgCode,(struct List *)TimeDateList);
  1077.  
  1078.                                 if(TimeList = BuildTimeList(TimeDateNode))
  1079.                                 {
  1080.                                     TimeSelected = 0;
  1081.  
  1082.                                     Selected = MsgCode;
  1083.  
  1084.                                     DisableGadgets(Handle,FALSE,FALSE,FALSE);
  1085.  
  1086.                                     TimeDateNode = (struct TimeDateNode *)GetListNode(Selected,(struct List *)TimeDateList);
  1087.  
  1088.                                     Rate2String(TimeDateNode->Table[TimeSelected].PayPerUnit[DT_FIRST_UNIT],PayString1);
  1089.  
  1090.                                     LT_SetAttributes(Handle,GAD_PAY1,
  1091.                                         GTST_String,    PayString1,
  1092.                                     TAG_DONE);
  1093.  
  1094.                                     Rate2String(TimeDateNode->Table[TimeSelected].SecPerUnit[DT_FIRST_UNIT],TimeString1);
  1095.  
  1096.                                     LT_SetAttributes(Handle,GAD_MINUTES1,
  1097.                                         GTST_String,    TimeString1,
  1098.                                     TAG_DONE);
  1099.  
  1100.                                     Rate2String(TimeDateNode->Table[TimeSelected].PayPerUnit[DT_NEXT_UNIT],PayString2);
  1101.  
  1102.                                     LT_SetAttributes(Handle,GAD_PAY2,
  1103.                                         GTST_String,    PayString2,
  1104.                                     TAG_DONE);
  1105.  
  1106.                                     Rate2String(TimeDateNode->Table[TimeSelected].SecPerUnit[DT_NEXT_UNIT],TimeString2);
  1107.  
  1108.                                     LT_SetAttributes(Handle,GAD_MINUTES2,
  1109.                                         GTST_String,    TimeString2,
  1110.                                     TAG_DONE);
  1111.  
  1112.                                     LT_SetAttributes(Handle,GAD_TIME,
  1113.                                         GTLV_Labels,    TimeList,
  1114.                                         GTLV_Selected,    0,
  1115.                                         GA_Disabled,    FALSE,
  1116.                                     TAG_DONE);
  1117.  
  1118.                                     LT_SetAttributes(Handle,GAD_ADDTIME,
  1119.                                         GA_Disabled,    FALSE,
  1120.                                     TAG_DONE);
  1121.  
  1122.                                     LT_SetAttributes(Handle,GAD_REMOVETIME,
  1123.                                         GA_Disabled,    TimeDateNode->Table[0].Count < 2,
  1124.                                     TAG_DONE);
  1125.  
  1126.                                     LT_SetAttributes(Handle,GAD_EDITTIME,
  1127.                                         GA_Disabled,    FALSE,
  1128.                                     TAG_DONE);
  1129.  
  1130.                                     LT_SetAttributes(Handle,GAD_EDIT,
  1131.                                         GA_Disabled,    !Selected,
  1132.                                     TAG_DONE);
  1133.  
  1134.                                     LT_SetAttributes(Handle,GAD_CLONE,
  1135.                                         GA_Disabled,    !Selected,
  1136.                                     TAG_DONE);
  1137.  
  1138.                                     LT_SetAttributes(Handle,GAD_REMOVE,
  1139.                                         GA_Disabled,    !Selected,
  1140.                                     TAG_DONE);
  1141.                                 }
  1142.                                 else
  1143.                                 {
  1144.                                     TimeDateNode = NULL;
  1145.  
  1146.                                     DisplayBeep(PanelWindow->WScreen);
  1147.  
  1148.                                     LT_SetAttributes(Handle,GAD_LIST,
  1149.                                         GTLV_Labels,    ~0,
  1150.                                     TAG_DONE);
  1151.  
  1152.                                     DisableGadgets(Handle,TRUE,TRUE,TRUE);
  1153.  
  1154.                                     LT_SetAttributes(Handle,GAD_LIST,
  1155.                                         GTLV_Labels,    TimeDateList,
  1156.                                         GTLV_Selected,    ~0,
  1157.                                     TAG_DONE);
  1158.  
  1159.                                     Selected = ~0;
  1160.  
  1161.                                     LT_SetAttributes(Handle,GAD_TIME,
  1162.                                         GTLV_Labels,    NULL,
  1163.                                         GTLV_Selected,    ~0,
  1164.                                         GA_Disabled,    TRUE,
  1165.                                     TAG_DONE);
  1166.  
  1167.                                     TimeSelected = ~0;
  1168.                                 }
  1169.  
  1170.                                 break;
  1171.  
  1172.                             case GAD_IMPORT:
  1173.  
  1174.                                 LT_LockWindow(PanelWindow);
  1175.  
  1176.                                 LT_SetAttributes(Handle,GAD_LIST,
  1177.                                     GTLV_Labels,    ~0,
  1178.                                 TAG_DONE);
  1179.  
  1180.                                 if(ImportPanel(PanelWindow,Entry,PhoneList,TimeDateList))
  1181.                                 {
  1182.                                     LT_SetAttributes(Handle,GAD_LIST,
  1183.                                         GTLV_Labels,    TimeDateList,
  1184.                                         GTLV_Selected,    ~0,
  1185.                                     TAG_DONE);
  1186.  
  1187.                                     Selected = ~0;
  1188.  
  1189.                                     LT_SetAttributes(Handle,GAD_TIME,
  1190.                                         GTLV_Labels,    TimeList,
  1191.                                         GTLV_Selected,    ~0,
  1192.                                     TAG_DONE);
  1193.  
  1194.                                     TimeSelected = ~0;
  1195.  
  1196.                                     DisableGadgets(Handle,TRUE,TRUE,TRUE);
  1197.  
  1198.                                     MadeChanges = TRUE;
  1199.                                 }
  1200.                                 else
  1201.                                 {
  1202.                                     LT_SetAttributes(Handle,GAD_LIST,
  1203.                                         GTLV_Labels,    TimeDateList,
  1204.                                         GTLV_Selected,    Selected,
  1205.                                     TAG_DONE);
  1206.                                 }
  1207.  
  1208.                                 LT_UnlockWindow(PanelWindow);
  1209.  
  1210.                                 LT_ShowWindow(Handle,TRUE);
  1211.  
  1212.                                 break;
  1213.  
  1214.                             case GAD_ADDDAY:
  1215.                             case GAD_ADDDATE:
  1216.  
  1217.                                 LT_LockWindow(PanelWindow);
  1218.  
  1219.                                 MadeChanges = TRUE;
  1220.  
  1221.                                 if(NewNode = CreateTimeDateNode(0,1,"",1))
  1222.                                 {
  1223.                                     BOOL Result;
  1224.  
  1225.                                     if(MsgGadgetID == GAD_ADDDAY)
  1226.                                     {
  1227.                                         NewNode->Header.Month    = -1;
  1228.                                         NewNode->Header.Day        = 0;
  1229.  
  1230.                                         Result = DayPanel(PanelWindow,NewNode);
  1231.                                     }
  1232.                                     else
  1233.                                         Result = DatePanel(PanelWindow,NewNode);
  1234.  
  1235.                                     if(Result)
  1236.                                     {
  1237.                                         AdaptTimeDateNode(NewNode);
  1238.  
  1239.                                         LT_SetAttributes(Handle,GAD_LIST,
  1240.                                             GTLV_Labels,    ~0,
  1241.                                         TAG_DONE);
  1242.  
  1243.                                         AddTail((struct List *)TimeDateList,&NewNode->VanillaNode);
  1244.  
  1245.                                         Selected = Count++;
  1246.  
  1247.                                         LT_SetAttributes(Handle,GAD_LIST,
  1248.                                             GTLV_Labels,        TimeDateList,
  1249.                                             GTLV_Selected,        Selected,
  1250.                                             GTLV_Top,            Selected,
  1251.                                             GTLV_MakeVisible,    Selected,
  1252.                                         TAG_DONE);
  1253.  
  1254.                                         TimeDateNode = NewNode;
  1255.  
  1256.                                         Redisplay = TRUE;
  1257.                                     }
  1258.                                     else
  1259.                                         FreeVecPooled(NewNode);
  1260.                                 }
  1261.  
  1262.                                 LT_UnlockWindow(PanelWindow);
  1263.  
  1264.                                 LT_ShowWindow(Handle,TRUE);
  1265.  
  1266.                                 break;
  1267.  
  1268.                             case GAD_REMOVE:
  1269.  
  1270.                                 if(--Count)
  1271.                                 {
  1272.                                     if(TimeDateNode->VanillaNode.ln_Succ->ln_Succ)
  1273.                                         NewNode = (struct TimeDateNode *)TimeDateNode->VanillaNode.ln_Succ;
  1274.                                     else
  1275.                                     {
  1276.                                         NewNode = (struct TimeDateNode *)TimeDateNode->VanillaNode.ln_Pred;
  1277.  
  1278.                                         TimeSelected--;
  1279.                                     }
  1280.                                 }
  1281.  
  1282.                                 MadeChanges = TRUE;
  1283.  
  1284.                                 LT_SetAttributes(Handle,GAD_LIST,
  1285.                                     GTLV_Labels,    ~0,
  1286.                                 TAG_DONE);
  1287.  
  1288.                                 Remove(TimeDateNode);
  1289.  
  1290.                                 FreeVecPooled(TimeDateNode);
  1291.  
  1292.                                 if(Count > 1)
  1293.                                 {
  1294.                                     LT_SetAttributes(Handle,GAD_LIST,
  1295.                                         GTLV_Labels,    TimeDateList,
  1296.                                         GTLV_Selected,    Count,
  1297.                                     TAG_DONE);
  1298.  
  1299.                                     TimeDateNode = NewNode;
  1300.  
  1301.                                     Redisplay = TRUE;
  1302.                                 }
  1303.                                 else
  1304.                                 {
  1305.                                     DisableGadgets(Handle,TRUE,TRUE,FALSE);
  1306.  
  1307.                                     LT_SetAttributes(Handle,GAD_LIST,
  1308.                                         GTLV_Labels,    TimeDateList,
  1309.                                         GTLV_Selected,    ~0,
  1310.                                     TAG_DONE);
  1311.  
  1312.                                     TimeDateNode = NULL;
  1313.                                 }
  1314.  
  1315.                                 break;
  1316.  
  1317.                             case GAD_CLONE:
  1318.  
  1319.                                 if(NewNode = CreateTimeDateNode(0,1,"",TimeDateNode->Table[0].Count))
  1320.                                 {
  1321.                                     MadeChanges = TRUE;
  1322.  
  1323.                                     strcpy(NewNode->VanillaNode.ln_Name = NewNode->Buffer,TimeDateNode->Buffer);
  1324.  
  1325.                                     NewNode->Header = TimeDateNode->Header;
  1326.  
  1327.                                     CopyMem(TimeDateNode->Table,NewNode->Table,sizeof(struct TimeDate) * TimeDateNode->Table[0].Count);
  1328.  
  1329.                                     AdaptTimeDateNode(NewNode);
  1330.  
  1331.                                     LT_SetAttributes(Handle,GAD_LIST,
  1332.                                         GTLV_Labels,    ~0,
  1333.                                     TAG_DONE);
  1334.  
  1335.                                     AddTail((struct List *)TimeDateList,&NewNode->VanillaNode);
  1336.  
  1337.                                     LT_SetAttributes(Handle,GAD_LIST,
  1338.                                         GTLV_Labels,    TimeDateList,
  1339.                                         GTLV_Selected,    Count++,
  1340.                                     TAG_DONE);
  1341.  
  1342.                                     TimeDateNode = NewNode;
  1343.  
  1344.                                     Redisplay = TRUE;
  1345.                                 }
  1346.  
  1347.                                 break;
  1348.  
  1349.                             case GAD_EDIT:
  1350.  
  1351.                                 LT_LockWindow(PanelWindow);
  1352.  
  1353.                                 LT_SetAttributes(Handle,GAD_LIST,
  1354.                                     GTLV_Labels,    ~0,
  1355.                                 TAG_DONE);
  1356.  
  1357.                                 if(TimeDateNode->Header.Month == -1)
  1358.                                     MadeChanges |= DayPanel(PanelWindow,TimeDateNode);
  1359.                                 else
  1360.                                     MadeChanges |= DatePanel(PanelWindow,TimeDateNode);
  1361.  
  1362.                                 AdaptTimeDateNode(TimeDateNode);
  1363.  
  1364.                                 LT_SetAttributes(Handle,GAD_LIST,
  1365.                                     GTLV_Labels,    TimeDateList,
  1366.                                     GTLV_Selected,    Selected,
  1367.                                 TAG_DONE);
  1368.  
  1369.                                 LT_UnlockWindow(PanelWindow);
  1370.  
  1371.                                 LT_ShowWindow(Handle,TRUE);
  1372.  
  1373.                                 break;
  1374.                         }
  1375.                     }
  1376.  
  1377.                     if(Redisplay)
  1378.                     {
  1379.                         Redisplay = FALSE;
  1380.  
  1381.                         LT_SetAttributes(Handle,GAD_TIME,
  1382.                             GTLV_Labels,    ~0,
  1383.                         TAG_DONE);
  1384.  
  1385.                         FreeVecPooled(TimeList);
  1386.  
  1387.                         if(TimeList = BuildTimeList(TimeDateNode))
  1388.                         {
  1389.                             if(TimeSelected == ~0)
  1390.                                 TimeSelected = 0;
  1391.  
  1392.                             DisableGadgets(Handle,FALSE,TRUE,FALSE);
  1393.  
  1394.                             Rate2String(TimeDateNode->Table[TimeSelected].PayPerUnit[DT_FIRST_UNIT],PayString1);
  1395.  
  1396.                             LT_SetAttributes(Handle,GAD_PAY1,
  1397.                                 GTST_String,    PayString1,
  1398.                             TAG_DONE);
  1399.  
  1400.                             Rate2String(TimeDateNode->Table[TimeSelected].SecPerUnit[DT_FIRST_UNIT],TimeString1);
  1401.  
  1402.                             LT_SetAttributes(Handle,GAD_MINUTES1,
  1403.                                 GTST_String,    TimeString1,
  1404.                             TAG_DONE);
  1405.  
  1406.                             Rate2String(TimeDateNode->Table[TimeSelected].PayPerUnit[DT_NEXT_UNIT],PayString2);
  1407.  
  1408.                             LT_SetAttributes(Handle,GAD_PAY2,
  1409.                                 GTST_String,    PayString2,
  1410.                             TAG_DONE);
  1411.  
  1412.                             Rate2String(TimeDateNode->Table[TimeSelected].SecPerUnit[DT_NEXT_UNIT],TimeString2);
  1413.  
  1414.                             LT_SetAttributes(Handle,GAD_MINUTES2,
  1415.                                 GTST_String,    TimeString2,
  1416.                             TAG_DONE);
  1417.  
  1418.                             LT_SetAttributes(Handle,GAD_TIME,
  1419.                                 GTLV_Labels,    TimeList,
  1420.                                 GTLV_Selected,    TimeSelected,
  1421.                                 GA_Disabled,    FALSE,
  1422.                             TAG_DONE);
  1423.  
  1424.                             LT_SetAttributes(Handle,GAD_ADDTIME,
  1425.                                 GA_Disabled,    FALSE,
  1426.                             TAG_DONE);
  1427.  
  1428.                             LT_SetAttributes(Handle,GAD_REMOVETIME,
  1429.                                 GA_Disabled,    TimeDateNode->Table[0].Count < 2,
  1430.                             TAG_DONE);
  1431.  
  1432.                             LT_SetAttributes(Handle,GAD_EDITTIME,
  1433.                                 GA_Disabled,    FALSE,
  1434.                             TAG_DONE);
  1435.  
  1436.                             LT_Activate(Handle,GAD_PAY1);
  1437.                         }
  1438.                         else
  1439.                         {
  1440.                             TimeDateNode = NULL;
  1441.  
  1442.                             LT_SetAttributes(Handle,GAD_LIST,
  1443.                                 GTLV_Labels,    TimeDateList,
  1444.                                 GTLV_Selected,    ~0,
  1445.                             TAG_DONE);
  1446.  
  1447.                             Selected = ~0;
  1448.  
  1449.                             LT_SetAttributes(Handle,GAD_TIME,
  1450.                                 GTLV_Labels,    NULL,
  1451.                                 GTLV_Selected,    ~0,
  1452.                             TAG_DONE);
  1453.  
  1454.                             TimeSelected = ~0;
  1455.  
  1456.                             DisableGadgets(Handle,TRUE,TRUE,TRUE);
  1457.  
  1458.                             DisplayBeep(PanelWindow->WScreen);
  1459.                         }
  1460.                     }
  1461.                 }
  1462.             }
  1463.             while(!Done);
  1464.  
  1465.             PopWindow();
  1466.  
  1467.             FreeVecPooled(TimeList);
  1468.         }
  1469.  
  1470.         LT_DeleteHandle(Handle);
  1471.     }
  1472.  
  1473.     return(MadeChanges);
  1474. }
  1475.